/*
 * JQuery zTree exHideNodes
 * v3.5.44
 * http://treejs.cn/
 *
 * Copyright (c) 2010 Hunter.z
 *
 * Licensed same as jquery - MIT License
 * http://www.opensource.org/licenses/mit-license.php
 *
 * Date: 2020-04-29
 */

(function ($) {
    var _setting = {
      data: {
        key: {
          isHidden: "isHidden"
        }
      }
    };
    //default init node of exLib
    var _initNode = function (setting, level, n, parentNode, isFirstNode, isLastNode, openFlag) {
        var isHidden = data.isHidden(setting, n);
        data.isHidden(setting, n, isHidden);
        data.initHideForExCheck(setting, n);
      },
      //add dom for check
      _beforeA = function (setting, node, html) {
      },
      //update zTreeObj, add method of exLib
      _zTreeTools = function (setting, zTreeTools) {
        zTreeTools.showNodes = function (nodes, options) {
          view.showNodes(setting, nodes, options);
        }
        zTreeTools.showNode = function (node, options) {
          if (!node) {
            return;
          }
          view.showNodes(setting, [node], options);
        }
        zTreeTools.hideNodes = function (nodes, options) {
          view.hideNodes(setting, nodes, options);
        }
        zTreeTools.hideNode = function (node, options) {
          if (!node) {
            return;
          }
          view.hideNodes(setting, [node], options);
        }
  
        var _checkNode = zTreeTools.checkNode;
        if (_checkNode) {
          zTreeTools.checkNode = function (node, checked, checkTypeFlag, callbackFlag) {
            if (!!node && !!data.isHidden(setting, node)) {
              return;
            }
            _checkNode.apply(zTreeTools, arguments);
          }
        }
      },
      //method of operate data
      _data = {
        initHideForExCheck: function (setting, n) {
          var isHidden = data.isHidden(setting, n);
          if (isHidden && setting.check && setting.check.enable) {
            if (typeof n._nocheck == "undefined") {
              n._nocheck = !!n.nocheck
              n.nocheck = true;
            }
            n.check_Child_State = -1;
            if (view.repairParentChkClassWithSelf) {
              view.repairParentChkClassWithSelf(setting, n);
            }
          }
        },
        initShowForExCheck: function (setting, n) {
          var isHidden = data.isHidden(setting, n);
          if (!isHidden && setting.check && setting.check.enable) {
            if (typeof n._nocheck != "undefined") {
              n.nocheck = n._nocheck;
              delete n._nocheck;
            }
            if (view.setChkClass) {
              var checkObj = $$(n, consts.id.CHECK, setting);
              view.setChkClass(setting, checkObj, n);
            }
            if (view.repairParentChkClassWithSelf) {
              view.repairParentChkClassWithSelf(setting, n);
            }
          }
        }
      },
      //method of operate ztree dom
      _view = {
        clearOldFirstNode: function (setting, node) {
          var n = node.getNextNode();
          while (!!n) {
            if (n.isFirstNode) {
              n.isFirstNode = false;
              view.setNodeLineIcos(setting, n);
              break;
            }
            if (n.isLastNode) {
              break;
            }
            n = n.getNextNode();
          }
        },
        clearOldLastNode: function (setting, node, openFlag) {
          var n = node.getPreNode();
          while (!!n) {
            if (n.isLastNode) {
              n.isLastNode = false;
              if (openFlag) {
                view.setNodeLineIcos(setting, n);
              }
              break;
            }
            if (n.isFirstNode) {
              break;
            }
            n = n.getPreNode();
          }
        },
        makeDOMNodeMainBefore: function (html, setting, node) {
          var isHidden = data.isHidden(setting, node);
          html.push("<li ", (isHidden ? "style='display:none;' " : ""), "id='", node.tId, "' class='", consts.className.LEVEL, node.level, "' tabindex='0' hidefocus='true' treenode>");
        },
        showNode: function (setting, node, options) {
          data.isHidden(setting, node, false);
          data.initShowForExCheck(setting, node);
          $$(node, setting).show();
        },
        showNodes: function (setting, nodes, options) {
          if (!nodes || nodes.length == 0) {
            return;
          }
          var pList = {}, i, j;
          for (i = 0, j = nodes.length; i < j; i++) {
            var n = nodes[i];
            if (!pList[n.parentTId]) {
              var pn = n.getParentNode();
              pList[n.parentTId] = (pn === null) ? data.getRoot(setting) : n.getParentNode();
            }
            view.showNode(setting, n, options);
          }
          for (var tId in pList) {
            var children = data.nodeChildren(setting, pList[tId]);
            view.setFirstNodeForShow(setting, children);
            view.setLastNodeForShow(setting, children);
          }
        },
        hideNode: function (setting, node, options) {
          data.isHidden(setting, node, true);
          node.isFirstNode = false;
          node.isLastNode = false;
          data.initHideForExCheck(setting, node);
          view.cancelPreSelectedNode(setting, node);
          $$(node, setting).hide();
        },
        hideNodes: function (setting, nodes, options) {
          if (!nodes || nodes.length == 0) {
            return;
          }
          var pList = {}, i, j;
          for (i = 0, j = nodes.length; i < j; i++) {
            var n = nodes[i];
            if ((n.isFirstNode || n.isLastNode) && !pList[n.parentTId]) {
              var pn = n.getParentNode();
              pList[n.parentTId] = (pn === null) ? data.getRoot(setting) : n.getParentNode();
            }
            view.hideNode(setting, n, options);
          }
          for (var tId in pList) {
            var children = data.nodeChildren(setting, pList[tId]);
            view.setFirstNodeForHide(setting, children);
            view.setLastNodeForHide(setting, children);
          }
        },
        setFirstNode: function (setting, parentNode) {
          var children = data.nodeChildren(setting, parentNode);
          var isHidden = data.isHidden(setting, children[0], false);
          if (children.length > 0 && !isHidden) {
            children[0].isFirstNode = true;
          } else if (children.length > 0) {
            view.setFirstNodeForHide(setting, children);
          }
        },
        setLastNode: function (setting, parentNode) {
          var children = data.nodeChildren(setting, parentNode);
          var isHidden = data.isHidden(setting, children[0]);
          if (children.length > 0 && !isHidden) {
            children[children.length - 1].isLastNode = true;
          } else if (children.length > 0) {
            view.setLastNodeForHide(setting, children);
          }
        },
        setFirstNodeForHide: function (setting, nodes) {
          var n, i, j;
          for (i = 0, j = nodes.length; i < j; i++) {
            n = nodes[i];
            if (n.isFirstNode) {
              break;
            }
            var isHidden = data.isHidden(setting, n);
            if (!isHidden && !n.isFirstNode) {
              n.isFirstNode = true;
              view.setNodeLineIcos(setting, n);
              break;
            } else {
              n = null;
            }
          }
          return n;
        },
        setFirstNodeForShow: function (setting, nodes) {
          var n, i, j, first, old;
          for (i = 0, j = nodes.length; i < j; i++) {
            n = nodes[i];
            var isHidden = data.isHidden(setting, n);
            if (!first && !isHidden && n.isFirstNode) {
              first = n;
              break;
            } else if (!first && !isHidden && !n.isFirstNode) {
              n.isFirstNode = true;
              first = n;
              view.setNodeLineIcos(setting, n);
            } else if (first && n.isFirstNode) {
              n.isFirstNode = false;
              old = n;
              view.setNodeLineIcos(setting, n);
              break;
            } else {
              n = null;
            }
          }
          return {"new": first, "old": old};
        },
        setLastNodeForHide: function (setting, nodes) {
          var n, i;
          for (i = nodes.length - 1; i >= 0; i--) {
            n = nodes[i];
            if (n.isLastNode) {
              break;
            }
            var isHidden = data.isHidden(setting, n);
            if (!isHidden && !n.isLastNode) {
              n.isLastNode = true;
              view.setNodeLineIcos(setting, n);
              break;
            } else {
              n = null;
            }
          }
          return n;
        },
        setLastNodeForShow: function (setting, nodes) {
          var n, i, j, last, old;
          for (i = nodes.length - 1; i >= 0; i--) {
            n = nodes[i];
            var isHidden = data.isHidden(setting, n);
            if (!last && !isHidden && n.isLastNode) {
              last = n;
              break;
            } else if (!last && !isHidden && !n.isLastNode) {
              n.isLastNode = true;
              last = n;
              view.setNodeLineIcos(setting, n);
            } else if (last && n.isLastNode) {
              n.isLastNode = false;
              old = n;
              view.setNodeLineIcos(setting, n);
              break;
            } else {
              n = null;
            }
          }
          return {"new": last, "old": old};
        }
      },
  
      _z = {
        view: _view,
        data: _data
      };
    $.extend(true, $.fn.zTree._z, _z);
  
    var zt = $.fn.zTree,
      tools = zt._z.tools,
      consts = zt.consts,
      view = zt._z.view,
      data = zt._z.data,
      event = zt._z.event,
      $$ = tools.$;
  
    data.isHidden = function (setting, node, newIsHidden) {
      if (!node) {
        return false;
      }
      var key = setting.data.key.isHidden;
      if (typeof newIsHidden !== 'undefined') {
        if (typeof newIsHidden === "string") {
          newIsHidden = tools.eqs(newIsHidden, "true");
        }
        newIsHidden = !!newIsHidden;
        node[key] = newIsHidden;
      } else if (typeof node[key] == "string"){
        node[key] = tools.eqs(node[key], "true");
      } else {
        node[key] = !!node[key];
      }
      return node[key];
    };
  
    data.exSetting(_setting);
    data.addInitNode(_initNode);
    data.addBeforeA(_beforeA);
    data.addZTreeTools(_zTreeTools);
  
  //	Override method in core
    var _dInitNode = data.initNode;
    data.initNode = function (setting, level, node, parentNode, isFirstNode, isLastNode, openFlag) {
      var tmpPNode = (parentNode) ? parentNode : data.getRoot(setting),
        children = tmpPNode[setting.data.key.children];
      data.tmpHideFirstNode = view.setFirstNodeForHide(setting, children);
      data.tmpHideLastNode = view.setLastNodeForHide(setting, children);
      if (openFlag) {
        view.setNodeLineIcos(setting, data.tmpHideFirstNode);
        view.setNodeLineIcos(setting, data.tmpHideLastNode);
      }
      isFirstNode = (data.tmpHideFirstNode === node);
      isLastNode = (data.tmpHideLastNode === node);
      if (_dInitNode) _dInitNode.apply(data, arguments);
      if (openFlag && isLastNode) {
        view.clearOldLastNode(setting, node, openFlag);
      }
    };
  
    var _makeChkFlag = data.makeChkFlag;
    if (!!_makeChkFlag) {
      data.makeChkFlag = function (setting, node) {
        if (!!node && !!data.isHidden(setting, node)) {
          return;
        }
        _makeChkFlag.apply(data, arguments);
      }
    }
  
    var _getTreeCheckedNodes = data.getTreeCheckedNodes;
    if (!!_getTreeCheckedNodes) {
      data.getTreeCheckedNodes = function (setting, nodes, checked, results) {
        if (!!nodes && nodes.length > 0) {
          var p = nodes[0].getParentNode();
          if (!!p && !!data.isHidden(setting, p)) {
            return [];
          }
        }
        return _getTreeCheckedNodes.apply(data, arguments);
      }
    }
  
    var _getTreeChangeCheckedNodes = data.getTreeChangeCheckedNodes;
    if (!!_getTreeChangeCheckedNodes) {
      data.getTreeChangeCheckedNodes = function (setting, nodes, results) {
        if (!!nodes && nodes.length > 0) {
          var p = nodes[0].getParentNode();
          if (!!p && !!data.isHidden(setting, p)) {
            return [];
          }
        }
        return _getTreeChangeCheckedNodes.apply(data, arguments);
      }
    }
  
    var _expandCollapseSonNode = view.expandCollapseSonNode;
    if (!!_expandCollapseSonNode) {
      view.expandCollapseSonNode = function (setting, node, expandFlag, animateFlag, callback) {
        if (!!node && !!data.isHidden(setting, node)) {
          return;
        }
        _expandCollapseSonNode.apply(view, arguments);
      }
    }
  
    var _setSonNodeCheckBox = view.setSonNodeCheckBox;
    if (!!_setSonNodeCheckBox) {
      view.setSonNodeCheckBox = function (setting, node, value, srcNode) {
        if (!!node && !!data.isHidden(setting, node)) {
          return;
        }
        _setSonNodeCheckBox.apply(view, arguments);
      }
    }
  
    var _repairParentChkClassWithSelf = view.repairParentChkClassWithSelf;
    if (!!_repairParentChkClassWithSelf) {
      view.repairParentChkClassWithSelf = function (setting, node) {
        if (!!node && !!data.isHidden(setting, node)) {
          return;
        }
        _repairParentChkClassWithSelf.apply(view, arguments);
      }
    }
  })(jQuery);